package 多态;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: lenovo
 * Date: 2022-06-29
 * Time: 16:51
 */
class Animal{
    private String name;
    private int age;


    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        eat();// 父类 构造方法里调用的方法也能实现动态绑定 但是以后不要这样写代码 除非考试考
    }

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {

        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"正在吃饭"+"(Animal)");
//        return new Animal("121",121);
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }
    public void bark(){
        System.out.println(getName()+"正在汪汪汪");
    }

    @Override
    public void eat() {
        System.out.println(getName()+"正在吃狗粮");
    }
}
class Cat extends Animal{
    public String catpaw;

    public Cat(String name, int age) {
        super(name, age);
    }
    public void miaomiao(){
        System.out.println(getName()+"正在喵喵喵");
    }
    public void Ninelives(){
        System.out.println("猫有九条命");
    }
    @Override
    /**
     * 1.方法名、参数(类型、个数、顺序)、返回值一样
     * 2.被static、private、final修饰的方法名不能重写
     * 3.子类的修饰符访问权限大于等于父类
     * 4.如果返回值不相同，那么返回值类型必须构成父子关系
     */
    public void eat(){
        System.out.println(getName()+"正在吃猫粮");
//        return new Cat("1551",1);
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal("动物",1);
        Dog dog = new Dog("狗子",2);

    }






    public static void main8(String[] args) {
        Animal animal = new Animal("动物",1);
        //为先向上转型
        if (animal instanceof Cat){
            Cat cat = (Cat) animal;
        }



    }


    public static void main6(String[] args) {
        Animal animal = new Dog("白虎",2);
      //通过instanceof来判断 如果结果为true则执行向下转型
        if ( animal instanceof Cat){
            //不是所有的动物都是猫 狗子不是猫
            Cat cat =(Cat) animal;
            cat.Ninelives();
        }

    }
    public static void main5(String[] args) {
        Animal animal = new Cat("小橘",1);
        //向下转型
       if (animal instanceof Cat){
           Cat cat =(Cat) animal;
           cat.Ninelives();
       }

    }







    public static void fun(Animal animal){
        animal.eat();
    }
    //      返回值类型 父类
    public static Animal funcc(){
        // 返回子类对象
        return new Cat("122",1);
    }
    public static void main4(String[] args) {
        fun(new Cat("小黑",1));
        fun(new Dog("白虎",1));

    }
















    public static void func(Animal animal){

    }
    public Animal fun(){
        return new Cat("45",1);//通过返回子类实现向上转型
    }
    public static void main3(String[] args) {
        Cat cat = new Cat("55",1);
        func(cat);//通过传参实现向上转型

    }
    public static void main2(String[] args) {
//        Cat cat = new Cat("小橘",2);
//        //向上转型
//        Animal animal = cat;
        //父类引用 引用了 之类的对象
        Animal animal1 = new Cat("小橘",2);
       animal1.eat();//调用的是Animal的eat
       // animal1是Animal类型的引用，相当于站在Animal的角度去看Cat的对象，无法访问到Cat类里的属性和方法，只能调用Animal自己的属性和方法，不可以调用子类的属性和方法
//        animal1.miaomiao();
//        animal1.catpaw;
    }
    public static void main1(String[] args) {
        Cat cat = new Cat("小橘",2);
        cat.eat();
        cat.miaomiao();

    }
}
